package MAIN;
//笔试强训第28天
//选择题
/*服务器端使用ServerSocket（int port）-默认在本地指定端口号监听TCP端口。 客户端使用Socket来连接
服务器，Socket(IP，port)*/
/*JRE：Java运行时环境，JDK：Java开发工具包，包含了JRE，我们一般写的代码都是前台线程，当所有的前台
线程（用户线程）执行完毕的时候，Java进程会认为程序全部执行完毕，后台线程：jvm垃圾回收线程，如果要将前台线
* 程修改成后台线程，需要setDameon(true)，此时一个前台线程就变成了后台线程*/
/*||是短路运算符，如果表达式1是正确的，此时直接返回，不会再执行第二个表达式*/
/*finally()是一个代码块，没有finally这个方法，finalize()这个方法是OBject类的方法*/
/*JDK垃圾回收器：Serial收集器，parNew收集器，CMS收集器，G1收集器是在jdk7之后才有的*/
/*instanceof是一个关键字，和==是一样的，作用是判断其左边的对象是否为其右边类的实例，返回的
是boolean类型*/
/*可以判断一个对象是否为一个类的实例，是否为一个实现指定接口的类的实例，是否为一个子类的实例*/
/*只要是算数运算，所有的类型都会转为最大的类型然后进行计算*/

import org.w3c.dom.ls.LSInput;

import javax.rmi.CORBA.Util;
import javax.xml.soap.Node;
import java.util.Scanner;

import static MAIN.util.swap;

class ListNode {
   public int value;
   public ListNode next;
   public ListNode(int val) {
       this.value = val;
   }
}

class util {
    //静态的泛型方法需要在static之后用<>声明泛型类型参数
    public static<E> void swap(E[] array,int i, int j) {
        E t = array[i];
        array[i] = array[j];
        array[j] = t;
    }
}
//编程题
public class Main28 {
    //先创建一个静态内部类表示节点
    static class ListNode {
        int val;
        ListNode next;

        public ListNode(int val) {
            this.val = val;
        }
    }
    public static ListNode head;
    public static ListNode reverseBetweenList(ListNode head, int left, int right) {
        ListNode res = new ListNode(-1);
        res.next = head;
        ListNode prev = res;
        for (int i = 1; i < left; i++) {
            prev = prev.next;
        }
        //此时prev引用就指向了待反转区间的前驱节点，cur指向的是反转区间的第一个节点
        ListNode cur = prev.next;
        for (int i = left; i < right; i++) {
            ListNode curNext = cur.next;
            cur.next = curNext.next;
            curNext.next = prev.next;
            prev.next = curNext;
        }
        return res.next;
    }

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        //有n个节点个数
        int n = scan.nextInt();
        //先吃掉这个换行符（因为输入之后按下回车nextLine这个方法认为这个回车是你输入的）
        //所以之后就没有下一次的输入直接跳过去了
        scan.nextLine();
        //一次读取了链表中的所有的节点
        String str = scan.nextLine();
        String[] nodes = str.split(" ");
        //进行链表的创建
        ListNode res = new ListNode(-1);
        ListNode tail = res;
        for (int i = 0; i < n; i++) {
            ListNode node = new ListNode(Integer.parseInt(nodes[i]));
            tail.next = node;
            tail = node;
        }
        //链表创建完成之后获取左区间和右区间
        String part = scan.nextLine();
        String[] parts = part.split(" ");
        int left = Integer.parseInt(parts[0]);
        int right = Integer.parseInt(parts[1]);
        //调用区间反转的方法
        ListNode newHead = reverseBetweenList(res.next,left,right);
        //进行打印（按照题目要求）
        ListNode cur = newHead;
        while (cur != null) {
            System.out.print(cur.val + " ");
            cur = cur.next;
        }
    }

    public static void main1(String[] args) {
        //反转部分单链表
        /*首先注意输入的处理：1.链表的每个节点的值都在一行输入结束了，每个节点的值用空格分割
        *此时就需要使用nextLine一次读取一行输入的值，然后用空格来拆分成字符数组*/
        /*2.从nextLine获取一个节点值之后，使用回车结束本次输入，/n就会被nextLine方法获取，
        * 在输入完节点个数之后，使用一次nextLine方法吃掉这个换行符之后再输入节点值。*/
        /*3.反转的区间是节点的编号，不是下标*/
    }

    //猴子分桃
    public static void main2(String[] args) {
        Scanner scan = new Scanner(System.in);
        long n = 0;
        while (scan.hasNext()) {
            n = scan.nextInt();
            if (n == 0) break;
            long a = (long)Math.pow(5, n);
            long b = (long)Math.pow(4, n);
            System.out.println((a - 4) + " " + (b - 4 + n));
        }
    }
}
